package org.xtext.telcodev.dsl.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
import org.xtext.telcodev.dsl.services.VoiSGrammarAccess;
import org.xtext.telcodev.dsl.voiS.Ask;
import org.xtext.telcodev.dsl.voiS.Assigment;
import org.xtext.telcodev.dsl.voiS.Block;
import org.xtext.telcodev.dsl.voiS.BlockState;
import org.xtext.telcodev.dsl.voiS.BoolLiteral;
import org.xtext.telcodev.dsl.voiS.BoolVariable;
import org.xtext.telcodev.dsl.voiS.CompareExpression;
import org.xtext.telcodev.dsl.voiS.Concatenation;
import org.xtext.telcodev.dsl.voiS.CondBlock;
import org.xtext.telcodev.dsl.voiS.CondStateBlock;
import org.xtext.telcodev.dsl.voiS.Dial;
import org.xtext.telcodev.dsl.voiS.Document;
import org.xtext.telcodev.dsl.voiS.GetDigits;
import org.xtext.telcodev.dsl.voiS.Hangup;
import org.xtext.telcodev.dsl.voiS.IfExp;
import org.xtext.telcodev.dsl.voiS.IfStateExp;
import org.xtext.telcodev.dsl.voiS.Literal;
import org.xtext.telcodev.dsl.voiS.NegExpression;
import org.xtext.telcodev.dsl.voiS.NumLiteral;
import org.xtext.telcodev.dsl.voiS.NumVariable;
import org.xtext.telcodev.dsl.voiS.Operation;
import org.xtext.telcodev.dsl.voiS.OperationBool;
import org.xtext.telcodev.dsl.voiS.Play;
import org.xtext.telcodev.dsl.voiS.Record;
import org.xtext.telcodev.dsl.voiS.Reject;
import org.xtext.telcodev.dsl.voiS.Save;
import org.xtext.telcodev.dsl.voiS.Say;
import org.xtext.telcodev.dsl.voiS.Send;
import org.xtext.telcodev.dsl.voiS.State;
import org.xtext.telcodev.dsl.voiS.StringLiteral;
import org.xtext.telcodev.dsl.voiS.StringVariable;
import org.xtext.telcodev.dsl.voiS.Transition;
import org.xtext.telcodev.dsl.voiS.VoiSPackage;

@SuppressWarnings("restriction")
public class AbstractVoiSSemanticSequencer extends AbstractSemanticSequencer {

	@Inject
	protected VoiSGrammarAccess grammarAccess;
	
	@Inject
	protected ISemanticSequencerDiagnosticProvider diagnosticProvider;
	
	@Inject
	protected ITransientValueService transientValues;
	
	@Inject
	@GenericSequencer
	protected Provider<ISemanticSequencer> genericSequencerProvider;
	
	protected ISemanticSequencer genericSequencer;
	
	
	@Override
	public void init(ISemanticSequencer sequencer, ISemanticSequenceAcceptor sequenceAcceptor, Acceptor errorAcceptor) {
		super.init(sequencer, sequenceAcceptor, errorAcceptor);
		this.genericSequencer = genericSequencerProvider.get();
		this.genericSequencer.init(sequencer, sequenceAcceptor, errorAcceptor);
	}
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == VoiSPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case VoiSPackage.ASK:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getAskRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVarsRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Ask(context, (Ask) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.ASSIGMENT:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getAssigmentRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule()) {
					sequence_Assigment(context, (Assigment) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.BLOCK:
				if(context == grammarAccess.getBlockRule()) {
					sequence_Block(context, (Block) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.BLOCK_STATE:
				if(context == grammarAccess.getBlockStateRule()) {
					sequence_BlockState(context, (BlockState) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.BOOL_LITERAL:
				if(context == grammarAccess.getBoolExpressionRule() ||
				   context == grammarAccess.getBoolExpressionAccess().getOperationBoolLeftAction_1_0() ||
				   context == grammarAccess.getBoolLiteralRule() ||
				   context == grammarAccess.getConcatenationExpressionRule() ||
				   context == grammarAccess.getConcatenationExpressionAccess().getConcatenationLeftAction_1_0() ||
				   context == grammarAccess.getConcatenationTerminalRule() ||
				   context == grammarAccess.getLiteralAbsRule() ||
				   context == grammarAccess.getTerminalBoolExpressionRule()) {
					sequence_BoolLiteral(context, (BoolLiteral) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.BOOL_VARIABLE:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getBoolVariableRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVarsRule()) {
					sequence_BoolVariable(context, (BoolVariable) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.COMPARE_EXPRESSION:
				if(context == grammarAccess.getBoolExpressionRule() ||
				   context == grammarAccess.getBoolExpressionAccess().getOperationBoolLeftAction_1_0() ||
				   context == grammarAccess.getCompareExpressionRule() ||
				   context == grammarAccess.getTerminalBoolExpressionRule()) {
					sequence_CompareExpression(context, (CompareExpression) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.CONCATENATION:
				if(context == grammarAccess.getConcatenationExpressionRule() ||
				   context == grammarAccess.getConcatenationExpressionAccess().getConcatenationLeftAction_1_0() ||
				   context == grammarAccess.getConcatenationTerminalRule()) {
					sequence_ConcatenationExpression(context, (Concatenation) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.COND_BLOCK:
				if(context == grammarAccess.getCondBlockRule()) {
					sequence_CondBlock(context, (CondBlock) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.COND_STATE_BLOCK:
				if(context == grammarAccess.getCondStateBlockRule()) {
					sequence_CondStateBlock(context, (CondStateBlock) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.DIAL:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getDialRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Dial(context, (Dial) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.DOCUMENT:
				if(context == grammarAccess.getDocumentRule()) {
					sequence_Document(context, (Document) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.GET_DIGITS:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getGetDigitsRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVarsRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_GetDigits(context, (GetDigits) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.HANGUP:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getHangupRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Hangup(context, (Hangup) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.IF_EXP:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getIfExpRule()) {
					sequence_IfExp(context, (IfExp) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.IF_STATE_EXP:
				if(context == grammarAccess.getIfStateExpRule() ||
				   context == grammarAccess.getStateAbstractElementRule()) {
					sequence_IfStateExp(context, (IfStateExp) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.LITERAL:
				if(context == grammarAccess.getBoolExpressionRule() ||
				   context == grammarAccess.getBoolExpressionAccess().getOperationBoolLeftAction_1_0() ||
				   context == grammarAccess.getConcatenationExpressionRule() ||
				   context == grammarAccess.getConcatenationExpressionAccess().getConcatenationLeftAction_1_0() ||
				   context == grammarAccess.getConcatenationTerminalRule() ||
				   context == grammarAccess.getLiteralRule() ||
				   context == grammarAccess.getLiteralAbsRule() ||
				   context == grammarAccess.getMathExpressionRule() ||
				   context == grammarAccess.getMathExpressionAccess().getOperationLeftAction_1_0() ||
				   context == grammarAccess.getMathTerminalRule() ||
				   context == grammarAccess.getTerminalBoolExpressionRule()) {
					sequence_Literal(context, (Literal) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.NEG_EXPRESSION:
				if(context == grammarAccess.getBoolExpressionRule() ||
				   context == grammarAccess.getBoolExpressionAccess().getOperationBoolLeftAction_1_0() ||
				   context == grammarAccess.getNegExpressionRule() ||
				   context == grammarAccess.getTerminalBoolExpressionRule()) {
					sequence_NegExpression(context, (NegExpression) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.NUM_LITERAL:
				if(context == grammarAccess.getBoolExpressionRule() ||
				   context == grammarAccess.getBoolExpressionAccess().getOperationBoolLeftAction_1_0() ||
				   context == grammarAccess.getConcatenationExpressionRule() ||
				   context == grammarAccess.getConcatenationExpressionAccess().getConcatenationLeftAction_1_0() ||
				   context == grammarAccess.getConcatenationTerminalRule() ||
				   context == grammarAccess.getLiteralRule() ||
				   context == grammarAccess.getLiteralAbsRule() ||
				   context == grammarAccess.getMathExpressionRule() ||
				   context == grammarAccess.getMathExpressionAccess().getOperationLeftAction_1_0() ||
				   context == grammarAccess.getMathTerminalRule() ||
				   context == grammarAccess.getNumLiteralRule() ||
				   context == grammarAccess.getTerminalBoolExpressionRule()) {
					sequence_NumLiteral(context, (NumLiteral) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.NUM_VARIABLE:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getNumVariableRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVarsRule()) {
					sequence_NumVariable(context, (NumVariable) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.OPERATION:
				if(context == grammarAccess.getMathExpressionRule() ||
				   context == grammarAccess.getMathExpressionAccess().getOperationLeftAction_1_0() ||
				   context == grammarAccess.getMathTerminalRule()) {
					sequence_MathExpression(context, (Operation) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.OPERATION_BOOL:
				if(context == grammarAccess.getBoolExpressionRule() ||
				   context == grammarAccess.getBoolExpressionAccess().getOperationBoolLeftAction_1_0() ||
				   context == grammarAccess.getTerminalBoolExpressionRule()) {
					sequence_BoolExpression(context, (OperationBool) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.PLAY:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getPlayRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Play(context, (Play) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.RECORD:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getRecordRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Record(context, (Record) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.REJECT:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getRejectRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Reject(context, (Reject) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.SAVE:
				if(context == grammarAccess.getSaveRule() ||
				   context == grammarAccess.getStateAbstractElementRule()) {
					sequence_Save(context, (Save) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.SAY:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getSayRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Say(context, (Say) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.SEND:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getSendRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getVoiceTagRule()) {
					sequence_Send(context, (Send) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.STATE:
				if(context == grammarAccess.getStateRule()) {
					sequence_State(context, (State) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.STRING_LITERAL:
				if(context == grammarAccess.getConcatenationExpressionRule() ||
				   context == grammarAccess.getConcatenationExpressionAccess().getConcatenationLeftAction_1_0() ||
				   context == grammarAccess.getConcatenationTerminalRule() ||
				   context == grammarAccess.getLiteralAbsRule() ||
				   context == grammarAccess.getStringLiteralRule()) {
					sequence_StringLiteral(context, (StringLiteral) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.STRING_VARIABLE:
				if(context == grammarAccess.getAbstractElementRule() ||
				   context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getStatementRule() ||
				   context == grammarAccess.getStringVariableRule() ||
				   context == grammarAccess.getVarsRule()) {
					sequence_StringVariable(context, (StringVariable) semanticObject); 
					return; 
				}
				else break;
			case VoiSPackage.TRANSITION:
				if(context == grammarAccess.getStateAbstractElementRule() ||
				   context == grammarAccess.getTransitionRule()) {
					sequence_Transition(context, (Transition) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (name=ID question=ConcatenationExpression choices=STRING?)
	 */
	protected void sequence_Ask(EObject context, Ask semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (va=[Vars|ID] right=MathExpression)
	 */
	protected void sequence_Assigment(EObject context, Assigment semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.ASSIGMENT__VA) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.ASSIGMENT__VA));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.ASSIGMENT__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.ASSIGMENT__RIGHT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAssigmentAccess().getVaVarsIDTerminalRuleCall_0_0_1(), semanticObject.getVa());
		feeder.accept(grammarAccess.getAssigmentAccess().getRightMathExpressionParserRuleCall_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     sta+=StateAbstractElement*
	 */
	protected void sequence_BlockState(EObject context, BlockState semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     stms+=AbstractElement*
	 */
	protected void sequence_Block(EObject context, Block semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (left=BoolExpression_OperationBool_1_0 op=LOGIC_WORD right=BoolExpression)
	 */
	protected void sequence_BoolExpression(EObject context, OperationBool semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.OPERATION_BOOL__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.OPERATION_BOOL__LEFT));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.OPERATION_BOOL__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.OPERATION_BOOL__OP));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.OPERATION_BOOL__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.OPERATION_BOOL__RIGHT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBoolExpressionAccess().getOperationBoolLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getBoolExpressionAccess().getOpLOGIC_WORDTerminalRuleCall_1_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getBoolExpressionAccess().getRightBoolExpressionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     value=BOOL
	 */
	protected void sequence_BoolLiteral(EObject context, BoolLiteral semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.BOOL_LITERAL__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.BOOL_LITERAL__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getBoolLiteralAccess().getValueBOOLTerminalRuleCall_1_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID value=BoolExpression?)
	 */
	protected void sequence_BoolVariable(EObject context, BoolVariable semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (left=LiteralAbs op=COMPARE right=LiteralAbs)
	 */
	protected void sequence_CompareExpression(EObject context, CompareExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.COMPARE_EXPRESSION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.COMPARE_EXPRESSION__LEFT));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.COMPARE_EXPRESSION__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.COMPARE_EXPRESSION__OP));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.COMPARE_EXPRESSION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.COMPARE_EXPRESSION__RIGHT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getCompareExpressionAccess().getLeftLiteralAbsParserRuleCall_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getCompareExpressionAccess().getOpCOMPARETerminalRuleCall_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getCompareExpressionAccess().getRightLiteralAbsParserRuleCall_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (left=ConcatenationExpression_Concatenation_1_0 op=CONCATENATION right=ConcatenationExpression)
	 */
	protected void sequence_ConcatenationExpression(EObject context, Concatenation semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.CONCATENATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.CONCATENATION__LEFT));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.CONCATENATION__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.CONCATENATION__OP));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.CONCATENATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.CONCATENATION__RIGHT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getConcatenationExpressionAccess().getConcatenationLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getConcatenationExpressionAccess().getOpCONCATENATIONTerminalRuleCall_1_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getConcatenationExpressionAccess().getRightConcatenationExpressionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (cond=TerminalBoolExpression action=Block)
	 */
	protected void sequence_CondBlock(EObject context, CondBlock semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.COND_BLOCK__COND) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.COND_BLOCK__COND));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.COND_BLOCK__ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.COND_BLOCK__ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getCondBlockAccess().getCondTerminalBoolExpressionParserRuleCall_1_0(), semanticObject.getCond());
		feeder.accept(grammarAccess.getCondBlockAccess().getActionBlockParserRuleCall_2_0(), semanticObject.getAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (cond=TerminalBoolExpression action=BlockState)
	 */
	protected void sequence_CondStateBlock(EObject context, CondStateBlock semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.COND_STATE_BLOCK__COND) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.COND_STATE_BLOCK__COND));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.COND_STATE_BLOCK__ACTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.COND_STATE_BLOCK__ACTION));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getCondStateBlockAccess().getCondTerminalBoolExpressionParserRuleCall_1_0(), semanticObject.getCond());
		feeder.accept(grammarAccess.getCondStateBlockAccess().getActionBlockStateParserRuleCall_2_0(), semanticObject.getAction());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     to=ConcatenationExpression
	 */
	protected void sequence_Dial(EObject context, Dial semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.DIAL__TO) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.DIAL__TO));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getDialAccess().getToConcatenationExpressionParserRuleCall_1_0(), semanticObject.getTo());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID states?='withStates'? elements+=AbstractElement* sta+=State*)
	 */
	protected void sequence_Document(EObject context, Document semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID question=ConcatenationExpression numDigits=INT)
	 */
	protected void sequence_GetDigits(EObject context, GetDigits semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.GET_DIGITS__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.GET_DIGITS__NAME));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.GET_DIGITS__QUESTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.GET_DIGITS__QUESTION));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.GET_DIGITS__NUM_DIGITS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.GET_DIGITS__NUM_DIGITS));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getGetDigitsAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getGetDigitsAccess().getQuestionConcatenationExpressionParserRuleCall_3_0(), semanticObject.getQuestion());
		feeder.accept(grammarAccess.getGetDigitsAccess().getNumDigitsINTTerminalRuleCall_5_0(), semanticObject.getNumDigits());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     name='hangup'
	 */
	protected void sequence_Hangup(EObject context, Hangup semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.HANGUP__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.HANGUP__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getHangupAccess().getNameHangupKeyword_0_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (block=CondBlock blocks+=CondBlock* defaultBlock=Block?)
	 */
	protected void sequence_IfExp(EObject context, IfExp semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (block=CondStateBlock blocks+=CondStateBlock* defaultBlock=BlockState?)
	 */
	protected void sequence_IfStateExp(EObject context, IfStateExp semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (v=[Vars|ID] | nul=NULL | ses=SESSION)
	 */
	protected void sequence_Literal(EObject context, Literal semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (left=MathExpression_Operation_1_0 op=MATH right=MathExpression)
	 */
	protected void sequence_MathExpression(EObject context, Operation semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.OPERATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.OPERATION__LEFT));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.OPERATION__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.OPERATION__OP));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.OPERATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.OPERATION__RIGHT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getMathExpressionAccess().getOperationLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getMathExpressionAccess().getOpMATHTerminalRuleCall_1_1_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getMathExpressionAccess().getRightMathExpressionParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (op=NEGATION obj=TerminalBoolExpression)
	 */
	protected void sequence_NegExpression(EObject context, NegExpression semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.NEG_EXPRESSION__OP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.NEG_EXPRESSION__OP));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.NEG_EXPRESSION__OBJ) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.NEG_EXPRESSION__OBJ));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getNegExpressionAccess().getOpNEGATIONTerminalRuleCall_0_0(), semanticObject.getOp());
		feeder.accept(grammarAccess.getNegExpressionAccess().getObjTerminalBoolExpressionParserRuleCall_1_0(), semanticObject.getObj());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     value=Number
	 */
	protected void sequence_NumLiteral(EObject context, NumLiteral semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID value=MathExpression?)
	 */
	protected void sequence_NumVariable(EObject context, NumVariable semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     file=ConcatenationExpression
	 */
	protected void sequence_Play(EObject context, Play semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.PLAY__FILE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.PLAY__FILE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getPlayAccess().getFileConcatenationExpressionParserRuleCall_1_0(), semanticObject.getFile());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (action=ConcatenationExpression time=INT? name=ID?)
	 */
	protected void sequence_Record(EObject context, Record semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name='reject'
	 */
	protected void sequence_Reject(EObject context, Reject semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.REJECT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.REJECT__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getRejectAccess().getNameRejectKeyword_0_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     that=[Vars|ID]
	 */
	protected void sequence_Save(EObject context, Save semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.SAVE__THAT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.SAVE__THAT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSaveAccess().getThatVarsIDTerminalRuleCall_1_0_1(), semanticObject.getThat());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     that=ConcatenationExpression
	 */
	protected void sequence_Say(EObject context, Say semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.SAY__THAT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.SAY__THAT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSayAccess().getThatConcatenationExpressionParserRuleCall_1_0(), semanticObject.getThat());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=STRING that=ConcatenationExpression uri=ConcatenationExpression)
	 */
	protected void sequence_Send(EObject context, Send semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.SEND__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.SEND__NAME));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.SEND__THAT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.SEND__THAT));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.SEND__URI) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.SEND__URI));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSendAccess().getNameSTRINGTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getSendAccess().getThatConcatenationExpressionParserRuleCall_2_0(), semanticObject.getThat());
		feeder.accept(grammarAccess.getSendAccess().getUriConcatenationExpressionParserRuleCall_4_0(), semanticObject.getUri());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID times=INT? timeout=INT? stms+=StateAbstractElement*)
	 */
	protected void sequence_State(EObject context, State semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     value=STRING
	 */
	protected void sequence_StringLiteral(EObject context, StringLiteral semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.STRING_LITERAL__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.STRING_LITERAL__VALUE));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID value=ConcatenationExpression?)
	 */
	protected void sequence_StringVariable(EObject context, StringVariable semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (target=[State|ID] event=EventEnum)
	 */
	protected void sequence_Transition(EObject context, Transition semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.TRANSITION__TARGET) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.TRANSITION__TARGET));
			if(transientValues.isValueTransient(semanticObject, VoiSPackage.Literals.TRANSITION__EVENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VoiSPackage.Literals.TRANSITION__EVENT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getTransitionAccess().getTargetStateIDTerminalRuleCall_1_0_1(), semanticObject.getTarget());
		feeder.accept(grammarAccess.getTransitionAccess().getEventEventEnumTerminalRuleCall_3_0(), semanticObject.getEvent());
		feeder.finish();
	}
}
